Supporting Relative Debugging for Large-scale UPC Programs

AbstractRelative debugging is a useful technique for locating errors that emerge from porting existing code to new programming language or to new computing platform. Recent attention on the UPC programming language has resulted in a number of conventional parallel programs, for example MPI programs, being ported to UPC. This paper gives an overview on the data distribution concepts used in UPC and establishes the challenges in supporting relative debugging technique for UPC programs that run on large supercomputers. The proposed solution is implemented on an existing parallel relative debugger CCDB, and the performance is evaluated on a Cray XE6 system with 16,348 cores

Climate change: the necessary, the possible and the desirable Earth League climate statement on the implications for climate policy from the 5th IPCC Assessment

The development of human civilisations has occurred at a time of stable climate. This climate stability is now threatened by human activity. The rising global climate risk occurs at a decisive moment for world development. World nations are currently discussing a global development agenda consequent to the Millennium Development Goals (MDGs), which ends in 2015. It is increasingly possible to envisage a world where absolute poverty is largely eradicated within one generation and where ambitious goals on universal access and equal opportunities for dignified lives are adopted. These grand aspirations for a world population approaching or even exceeding nine billion in 2050 is threatened by substantial global environmental risks and by rising inequality. Research shows that development gains, in both rich and poor nations, can be undermined by social, economic and ecological problems caused by human-induced global environmental change. Climate risks, and associated changes in marine and terrestrial ecosystems that regulate the resilience of the climate system, are at the forefront of these global risks. We, as citizens with a strong engagement in Earth system science and socio-ecological dynamics, share the vision of a more equitable and prosperous future for the world, yet we also see threats to this future from shifts in climate and environmental processes. Without collaborative action now, our shared Earth system may not be able to sustainably support a large proportion of humanity in the decades ahead

Data centric highly parallel debugging

Debugging parallel programs is an order of magnitudemore complex than sequential ones, and yet, most parallel debuggers provide little extra functionality than their sequential counterparts. This problem becomes more serious as computational codes become more complex, involving larger data structures, and as the machines become larger. Peta-scale machines consisting of millions of cores pose a significant challenge for existing techniques. We argue that debugging must become more data-centric, and believe that "assertions" provide a useful model. Assertions allow a user to declare their expectations about the program state as a whole rather than focusing on that of only a single process state. Previously, we have implemented a special type of assertion that supports debugging applications as they evolve or are ported to different platforms. They allow a user to compare the state of one program against another reference version. These 'relative debugging' assertions, whilst powerful, pose significant implementation challenges for large peta-scale machines. In this paper we discuss a hashing technique that provides a scalable solution for very large problems on very large machines. We illustrate the scheme on 65k cores of Kraken, a Cray XT5 at the University of Tennessee. Copyright 2010 ACM

Assertion Based Parallel Debugging

Programming languages have advanced tremendously over the years, but program debuggers have hardly changed. Sequential debuggers do little more than allow a user to control the flow of a program and examine its state. Parallel ones support the same operations on multiple processes, which are adequate with a small number of processors, but become unwieldy and ineffective on very large machines. Typical scientific codes have enormous multi-dimensional data structures and it is impractical to expect a user to view the data using traditional display techniques. In this paper we discuss the use of debug-time assertions, and show that these can be used to debug parallel programs. The techniques reduce the debugging complexity because they reason about the state of large arrays without requiring the user to know the expected value of every element. Assertions can be expensive to evaluate, but their performance can be improved by running them in parallel. We demonstrate the system with a case study finding errors in a parallel version of the Shallow Water Equations, and evaluate the performance of the tool on a 4,096 cores Cray XE6

Debugging scientific applications with statistical assertions

Traditional debuggers are of limited value for modern scientific codes that manipulate large complex data structures. Current parallel machines make this even more complicated, because the data may be distributed across multiple processors, making it difficult to view, interpret and validate the contents of a distributed structure. As a result, many applications' developers resort to placing validation and display code directly in the source program itself. This paper discusses a novel debug-time assertion, called a "Statistical Assertion", that allows a user to reason about large data structures. We present the design and implementation of statistical assertions, and illustrate the debugging technique with a molecular dynamics simulation. We evaluate the performance of the system on a 12, 000 processor Cray XE6, and show that it is useful for real time debugging

Scalable parallel debugging with statistical assertions

Traditional debuggers are of limited value for modern scientific codes that manipulate large complex data structures. This paper discusses a novel debug-time assertion, called a "Statistical Assertion", that allows a user to reason about large data structures, and the primitives are parallelised to provide an efficient solution. We present the design and implementation of statistical assertions, and illustrate the debugging technique with a molecular dynamics simulation. We evaluate the performance of the tool on a 12,000 cores Cray XE6